/*
 * JSON Formatter from VSCode
 */

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var json = (function() {
  var exports = {};
  exports.__esModule = true;
  exports.getNodeType = exports.stripComments = exports.visit = exports.findNodeAtOffset = exports.contains = exports.getNodeValue = exports.getNodePath = exports.findNodeAtLocation = exports.parseTree = exports.parse = exports.getLocation = exports.createScanner = exports.ParseOptions = void 0;
  var ParseOptions;
  (function (ParseOptions) {
      ParseOptions.DEFAULT = {
          allowTrailingComma: true
      };
  })(ParseOptions = exports.ParseOptions || (exports.ParseOptions = {}));
  /**
   * Creates a JSON scanner on the given text.
   * If ignoreTrivia is set, whitespaces or comments are ignored.
   */
  function createScanner(text, ignoreTrivia) {
      if (ignoreTrivia === void 0) { ignoreTrivia = false; }
      var pos = 0, len = text.length, value = '', tokenOffset = 0, token = 16 /* Unknown */, scanError = 0 /* None */;
      function scanHexDigits(count) {
          var digits = 0;
          var hexValue = 0;
          while (digits < count) {
              var ch = text.charCodeAt(pos);
              if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
                  hexValue = hexValue * 16 + ch - 48 /* _0 */;
              }
              else if (ch >= 65 /* A */ && ch <= 70 /* F */) {
                  hexValue = hexValue * 16 + ch - 65 /* A */ + 10;
              }
              else if (ch >= 97 /* a */ && ch <= 102 /* f */) {
                  hexValue = hexValue * 16 + ch - 97 /* a */ + 10;
              }
              else {
                  break;
              }
              pos++;
              digits++;
          }
          if (digits < count) {
              hexValue = -1;
          }
          return hexValue;
      }
      function setPosition(newPosition) {
          pos = newPosition;
          value = '';
          tokenOffset = 0;
          token = 16 /* Unknown */;
          scanError = 0 /* None */;
      }
      function scanNumber() {
          var start = pos;
          if (text.charCodeAt(pos) === 48 /* _0 */) {
              pos++;
          }
          else {
              pos++;
              while (pos < text.length && isDigit(text.charCodeAt(pos))) {
                  pos++;
              }
          }
          if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {
              pos++;
              if (pos < text.length && isDigit(text.charCodeAt(pos))) {
                  pos++;
                  while (pos < text.length && isDigit(text.charCodeAt(pos))) {
                      pos++;
                  }
              }
              else {
                  scanError = 3 /* UnexpectedEndOfNumber */;
                  return text.substring(start, pos);
              }
          }
          var end = pos;
          if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {
              pos++;
              if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {
                  pos++;
              }
              if (pos < text.length && isDigit(text.charCodeAt(pos))) {
                  pos++;
                  while (pos < text.length && isDigit(text.charCodeAt(pos))) {
                      pos++;
                  }
                  end = pos;
              }
              else {
                  scanError = 3 /* UnexpectedEndOfNumber */;
              }
          }
          return text.substring(start, end);
      }
      function scanString() {
          var result = '', start = pos;
          while (true) {
              if (pos >= len) {
                  result += text.substring(start, pos);
                  scanError = 2 /* UnexpectedEndOfString */;
                  break;
              }
              var ch = text.charCodeAt(pos);
              if (ch === 34 /* doubleQuote */) {
                  result += text.substring(start, pos);
                  pos++;
                  break;
              }
              if (ch === 92 /* backslash */) {
                  result += text.substring(start, pos);
                  pos++;
                  if (pos >= len) {
                      scanError = 2 /* UnexpectedEndOfString */;
                      break;
                  }
                  var ch2 = text.charCodeAt(pos++);
                  switch (ch2) {
                      case 34 /* doubleQuote */:
                          result += '\"';
                          break;
                      case 92 /* backslash */:
                          result += '\\';
                          break;
                      case 47 /* slash */:
                          result += '/';
                          break;
                      case 98 /* b */:
                          result += '\b';
                          break;
                      case 102 /* f */:
                          result += '\f';
                          break;
                      case 110 /* n */:
                          result += '\n';
                          break;
                      case 114 /* r */:
                          result += '\r';
                          break;
                      case 116 /* t */:
                          result += '\t';
                          break;
                      case 117 /* u */:
                          var ch3 = scanHexDigits(4);
                          if (ch3 >= 0) {
                              result += String.fromCharCode(ch3);
                          }
                          else {
                              scanError = 4 /* InvalidUnicode */;
                          }
                          break;
                      default:
                          scanError = 5 /* InvalidEscapeCharacter */;
                  }
                  start = pos;
                  continue;
              }
              if (ch >= 0 && ch <= 0x1F) {
                  if (isLineBreak(ch)) {
                      result += text.substring(start, pos);
                      scanError = 2 /* UnexpectedEndOfString */;
                      break;
                  }
                  else {
                      scanError = 6 /* InvalidCharacter */;
                      // mark as error but continue with string
                  }
              }
              pos++;
          }
          return result;
      }
      function scanNext() {
          value = '';
          scanError = 0 /* None */;
          tokenOffset = pos;
          if (pos >= len) {
              // at the end
              tokenOffset = len;
              return token = 17 /* EOF */;
          }
          var code = text.charCodeAt(pos);
          // trivia: whitespace
          if (isWhitespace(code)) {
              do {
                  pos++;
                  value += String.fromCharCode(code);
                  code = text.charCodeAt(pos);
              } while (isWhitespace(code));
              return token = 15 /* Trivia */;
          }
          // trivia: newlines
          if (isLineBreak(code)) {
              pos++;
              value += String.fromCharCode(code);
              if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {
                  pos++;
                  value += '\n';
              }
              return token = 14 /* LineBreakTrivia */;
          }
          switch (code) {
              // tokens: []{}:,
              case 123 /* openBrace */:
                  pos++;
                  return token = 1 /* OpenBraceToken */;
              case 125 /* closeBrace */:
                  pos++;
                  return token = 2 /* CloseBraceToken */;
              case 91 /* openBracket */:
                  pos++;
                  return token = 3 /* OpenBracketToken */;
              case 93 /* closeBracket */:
                  pos++;
                  return token = 4 /* CloseBracketToken */;
              case 58 /* colon */:
                  pos++;
                  return token = 6 /* ColonToken */;
              case 44 /* comma */:
                  pos++;
                  return token = 5 /* CommaToken */;
              // strings
              case 34 /* doubleQuote */:
                  pos++;
                  value = scanString();
                  return token = 10 /* StringLiteral */;
              // comments
              case 47 /* slash */:
                  var start = pos - 1;
                  // Single-line comment
                  if (text.charCodeAt(pos + 1) === 47 /* slash */) {
                      pos += 2;
                      while (pos < len) {
                          if (isLineBreak(text.charCodeAt(pos))) {
                              break;
                          }
                          pos++;
                      }
                      value = text.substring(start, pos);
                      return token = 12 /* LineCommentTrivia */;
                  }
                  // Multi-line comment
                  if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
                      pos += 2;
                      var safeLength = len - 1; // For lookahead.
                      var commentClosed = false;
                      while (pos < safeLength) {
                          var ch = text.charCodeAt(pos);
                          if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
                              pos += 2;
                              commentClosed = true;
                              break;
                          }
                          pos++;
                      }
                      if (!commentClosed) {
                          pos++;
                          scanError = 1 /* UnexpectedEndOfComment */;
                      }
                      value = text.substring(start, pos);
                      return token = 13 /* BlockCommentTrivia */;
                  }
                  // just a single slash
                  value += String.fromCharCode(code);
                  pos++;
                  return token = 16 /* Unknown */;
              // numbers
              case 45 /* minus */:
                  value += String.fromCharCode(code);
                  pos++;
                  if (pos === len || !isDigit(text.charCodeAt(pos))) {
                      return token = 16 /* Unknown */;
                  }
              // found a minus, followed by a number so
              // we fall through to proceed with scanning
              // numbers
              case 48 /* _0 */:
              case 49 /* _1 */:
              case 50 /* _2 */:
              case 51 /* _3 */:
              case 52 /* _4 */:
              case 53 /* _5 */:
              case 54 /* _6 */:
              case 55 /* _7 */:
              case 56 /* _8 */:
              case 57 /* _9 */:
                  value += scanNumber();
                  return token = 11 /* NumericLiteral */;
              // literals and unknown symbols
              default:
                  // is a literal? Read the full word.
                  while (pos < len && isUnknownContentCharacter(code)) {
                      pos++;
                      code = text.charCodeAt(pos);
                  }
                  if (tokenOffset !== pos) {
                      value = text.substring(tokenOffset, pos);
                      // keywords: true, false, null
                      switch (value) {
                          case 'true': return token = 8 /* TrueKeyword */;
                          case 'false': return token = 9 /* FalseKeyword */;
                          case 'null': return token = 7 /* NullKeyword */;
                      }
                      return token = 16 /* Unknown */;
                  }
                  // some
                  value += String.fromCharCode(code);
                  pos++;
                  return token = 16 /* Unknown */;
          }
      }
      function isUnknownContentCharacter(code) {
          if (isWhitespace(code) || isLineBreak(code)) {
              return false;
          }
          switch (code) {
              case 125 /* closeBrace */:
              case 93 /* closeBracket */:
              case 123 /* openBrace */:
              case 91 /* openBracket */:
              case 34 /* doubleQuote */:
              case 58 /* colon */:
              case 44 /* comma */:
              case 47 /* slash */:
                  return false;
          }
          return true;
      }
      function scanNextNonTrivia() {
          var result;
          do {
              result = scanNext();
          } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);
          return result;
      }
      return {
          setPosition: setPosition,
          getPosition: function () { return pos; },
          scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
          getToken: function () { return token; },
          getTokenValue: function () { return value; },
          getTokenOffset: function () { return tokenOffset; },
          getTokenLength: function () { return pos - tokenOffset; },
          getTokenError: function () { return scanError; }
      };
  }
  exports.createScanner = createScanner;
  function isWhitespace(ch) {
      return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||
          ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||
          ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
  }
  function isLineBreak(ch) {
      return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
  }
  function isDigit(ch) {
      return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
  }
  /**
   * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.
   */
  function getLocation(text, position) {
      var segments = []; // strings or numbers
      var earlyReturnException = new Object();
      var previousNode = undefined;
      var previousNodeInst = {
          value: {},
          offset: 0,
          length: 0,
          type: 'object',
          parent: undefined
      };
      var isAtPropertyKey = false;
      function setPreviousNode(value, offset, length, type) {
          previousNodeInst.value = value;
          previousNodeInst.offset = offset;
          previousNodeInst.length = length;
          previousNodeInst.type = type;
          previousNodeInst.colonOffset = undefined;
          previousNode = previousNodeInst;
      }
      try {
          visit(text, {
              onObjectBegin: function (offset, length) {
                  if (position <= offset) {
                      throw earlyReturnException;
                  }
                  previousNode = undefined;
                  isAtPropertyKey = position > offset;
                  segments.push(''); // push a placeholder (will be replaced)
              },
              onObjectProperty: function (name, offset, length) {
                  if (position < offset) {
                      throw earlyReturnException;
                  }
                  setPreviousNode(name, offset, length, 'property');
                  segments[segments.length - 1] = name;
                  if (position <= offset + length) {
                      throw earlyReturnException;
                  }
              },
              onObjectEnd: function (offset, length) {
                  if (position <= offset) {
                      throw earlyReturnException;
                  }
                  previousNode = undefined;
                  segments.pop();
              },
              onArrayBegin: function (offset, length) {
                  if (position <= offset) {
                      throw earlyReturnException;
                  }
                  previousNode = undefined;
                  segments.push(0);
              },
              onArrayEnd: function (offset, length) {
                  if (position <= offset) {
                      throw earlyReturnException;
                  }
                  previousNode = undefined;
                  segments.pop();
              },
              onLiteralValue: function (value, offset, length) {
                  if (position < offset) {
                      throw earlyReturnException;
                  }
                  setPreviousNode(value, offset, length, getNodeType(value));
                  if (position <= offset + length) {
                      throw earlyReturnException;
                  }
              },
              onSeparator: function (sep, offset, length) {
                  if (position <= offset) {
                      throw earlyReturnException;
                  }
                  if (sep === ':' && previousNode && previousNode.type === 'property') {
                      previousNode.colonOffset = offset;
                      isAtPropertyKey = false;
                      previousNode = undefined;
                  }
                  else if (sep === ',') {
                      var last = segments[segments.length - 1];
                      if (typeof last === 'number') {
                          segments[segments.length - 1] = last + 1;
                      }
                      else {
                          isAtPropertyKey = true;
                          segments[segments.length - 1] = '';
                      }
                      previousNode = undefined;
                  }
              }
          });
      }
      catch (e) {
          if (e !== earlyReturnException) {
              throw e;
          }
      }
      return {
          path: segments,
          previousNode: previousNode,
          isAtPropertyKey: isAtPropertyKey,
          matches: function (pattern) {
              var k = 0;
              for (var i = 0; k < pattern.length && i < segments.length; i++) {
                  if (pattern[k] === segments[i] || pattern[k] === '*') {
                      k++;
                  }
                  else if (pattern[k] !== '**') {
                      return false;
                  }
              }
              return k === pattern.length;
          }
      };
  }
  exports.getLocation = getLocation;
  /**
   * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
   * Therefore always check the errors list to find out if the input was valid.
   */
  function parse(text, errors, options) {
      if (errors === void 0) { errors = []; }
      if (options === void 0) { options = ParseOptions.DEFAULT; }
      var currentProperty = null;
      var currentParent = [];
      var previousParents = [];
      function onValue(value) {
          if (Array.isArray(currentParent)) {
              currentParent.push(value);
          }
          else if (currentProperty !== null) {
              currentParent[currentProperty] = value;
          }
      }
      var visitor = {
          onObjectBegin: function () {
              var object = {};
              onValue(object);
              previousParents.push(currentParent);
              currentParent = object;
              currentProperty = null;
          },
          onObjectProperty: function (name) {
              currentProperty = name;
          },
          onObjectEnd: function () {
              currentParent = previousParents.pop();
          },
          onArrayBegin: function () {
              var array = [];
              onValue(array);
              previousParents.push(currentParent);
              currentParent = array;
              currentProperty = null;
          },
          onArrayEnd: function () {
              currentParent = previousParents.pop();
          },
          onLiteralValue: onValue,
          onError: function (error, offset, length) {
              errors.push({ error: error, offset: offset, length: length });
          }
      };
      visit(text, visitor, options);
      return currentParent[0];
  }
  exports.parse = parse;
  /**
   * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
   */
  function parseTree(text, errors, options) {
      if (errors === void 0) { errors = []; }
      if (options === void 0) { options = ParseOptions.DEFAULT; }
      var currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root
      function ensurePropertyComplete(endOffset) {
          if (currentParent.type === 'property') {
              currentParent.length = endOffset - currentParent.offset;
              currentParent = currentParent.parent;
          }
      }
      function onValue(valueNode) {
          currentParent.children.push(valueNode);
          return valueNode;
      }
      var visitor = {
          onObjectBegin: function (offset) {
              currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });
          },
          onObjectProperty: function (name, offset, length) {
              currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });
              currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });
          },
          onObjectEnd: function (offset, length) {
              currentParent.length = offset + length - currentParent.offset;
              currentParent = currentParent.parent;
              ensurePropertyComplete(offset + length);
          },
          onArrayBegin: function (offset, length) {
              currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });
          },
          onArrayEnd: function (offset, length) {
              currentParent.length = offset + length - currentParent.offset;
              currentParent = currentParent.parent;
              ensurePropertyComplete(offset + length);
          },
          onLiteralValue: function (value, offset, length) {
              onValue({ type: getNodeType(value), offset: offset, length: length, parent: currentParent, value: value });
              ensurePropertyComplete(offset + length);
          },
          onSeparator: function (sep, offset, length) {
              if (currentParent.type === 'property') {
                  if (sep === ':') {
                      currentParent.colonOffset = offset;
                  }
                  else if (sep === ',') {
                      ensurePropertyComplete(offset);
                  }
              }
          },
          onError: function (error, offset, length) {
              errors.push({ error: error, offset: offset, length: length });
          }
      };
      visit(text, visitor, options);
      var result = currentParent.children[0];
      if (result) {
          delete result.parent;
      }
      return result;
  }
  exports.parseTree = parseTree;
  /**
   * Finds the node at the given path in a JSON DOM.
   */
  function findNodeAtLocation(root, path) {
      if (!root) {
          return undefined;
      }
      var node = root;
      for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {
          var segment = path_1[_i];
          if (typeof segment === 'string') {
              if (node.type !== 'object' || !Array.isArray(node.children)) {
                  return undefined;
              }
              var found = false;
              for (var _a = 0, _b = node.children; _a < _b.length; _a++) {
                  var propertyNode = _b[_a];
                  if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {
                      node = propertyNode.children[1];
                      found = true;
                      break;
                  }
              }
              if (!found) {
                  return undefined;
              }
          }
          else {
              var index = segment;
              if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {
                  return undefined;
              }
              node = node.children[index];
          }
      }
      return node;
  }
  exports.findNodeAtLocation = findNodeAtLocation;
  /**
   * Gets the JSON path of the given JSON DOM node
   */
  function getNodePath(node) {
      if (!node.parent || !node.parent.children) {
          return [];
      }
      var path = getNodePath(node.parent);
      if (node.parent.type === 'property') {
          var key = node.parent.children[0].value;
          path.push(key);
      }
      else if (node.parent.type === 'array') {
          var index = node.parent.children.indexOf(node);
          if (index !== -1) {
              path.push(index);
          }
      }
      return path;
  }
  exports.getNodePath = getNodePath;
  /**
   * Evaluates the JavaScript object of the given JSON DOM node
   */
  function getNodeValue(node) {
      switch (node.type) {
          case 'array':
              return node.children.map(getNodeValue);
          case 'object':
              var obj = Object.create(null);
              for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
                  var prop = _a[_i];
                  var valueNode = prop.children[1];
                  if (valueNode) {
                      obj[prop.children[0].value] = getNodeValue(valueNode);
                  }
              }
              return obj;
          case 'null':
          case 'string':
          case 'number':
          case 'boolean':
              return node.value;
          default:
              return undefined;
      }
  }
  exports.getNodeValue = getNodeValue;
  function contains(node, offset, includeRightBound) {
      if (includeRightBound === void 0) { includeRightBound = false; }
      return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));
  }
  exports.contains = contains;
  /**
   * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.
   */
  function findNodeAtOffset(node, offset, includeRightBound) {
      if (includeRightBound === void 0) { includeRightBound = false; }
      if (contains(node, offset, includeRightBound)) {
          var children = node.children;
          if (Array.isArray(children)) {
              for (var i = 0; i < children.length && children[i].offset <= offset; i++) {
                  var item = findNodeAtOffset(children[i], offset, includeRightBound);
                  if (item) {
                      return item;
                  }
              }
          }
          return node;
      }
      return undefined;
  }
  exports.findNodeAtOffset = findNodeAtOffset;
  /**
   * Parses the given text and invokes the visitor functions for each object, array and literal reached.
   */
  function visit(text, visitor, options) {
      if (options === void 0) { options = ParseOptions.DEFAULT; }
      var _scanner = createScanner(text, false);
      function toNoArgVisit(visitFunction) {
          return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()); } : function () { return true; };
      }
      function toOneArgVisit(visitFunction) {
          return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()); } : function () { return true; };
      }
      var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
      var disallowComments = options && options.disallowComments;
      var allowTrailingComma = options && options.allowTrailingComma;
      function scanNext() {
          while (true) {
              var token = _scanner.scan();
              switch (_scanner.getTokenError()) {
                  case 4 /* InvalidUnicode */:
                      handleError(14 /* InvalidUnicode */);
                      break;
                  case 5 /* InvalidEscapeCharacter */:
                      handleError(15 /* InvalidEscapeCharacter */);
                      break;
                  case 3 /* UnexpectedEndOfNumber */:
                      handleError(13 /* UnexpectedEndOfNumber */);
                      break;
                  case 1 /* UnexpectedEndOfComment */:
                      if (!disallowComments) {
                          handleError(11 /* UnexpectedEndOfComment */);
                      }
                      break;
                  case 2 /* UnexpectedEndOfString */:
                      handleError(12 /* UnexpectedEndOfString */);
                      break;
                  case 6 /* InvalidCharacter */:
                      handleError(16 /* InvalidCharacter */);
                      break;
              }
              switch (token) {
                  case 12 /* LineCommentTrivia */:
                  case 13 /* BlockCommentTrivia */:
                      if (disallowComments) {
                          handleError(10 /* InvalidCommentToken */);
                      }
                      else {
                          onComment();
                      }
                      break;
                  case 16 /* Unknown */:
                      handleError(1 /* InvalidSymbol */);
                      break;
                  case 15 /* Trivia */:
                  case 14 /* LineBreakTrivia */:
                      break;
                  default:
                      return token;
              }
          }
      }
      function handleError(error, skipUntilAfter, skipUntil) {
          if (skipUntilAfter === void 0) { skipUntilAfter = []; }
          if (skipUntil === void 0) { skipUntil = []; }
          onError(error);
          if (skipUntilAfter.length + skipUntil.length > 0) {
              var token = _scanner.getToken();
              while (token !== 17 /* EOF */) {
                  if (skipUntilAfter.indexOf(token) !== -1) {
                      scanNext();
                      break;
                  }
                  else if (skipUntil.indexOf(token) !== -1) {
                      break;
                  }
                  token = scanNext();
              }
          }
      }
      function parseString(isValue) {
          var value = _scanner.getTokenValue();
          if (isValue) {
              onLiteralValue(value);
          }
          else {
              onObjectProperty(value);
          }
          scanNext();
          return true;
      }
      function parseLiteral() {
          switch (_scanner.getToken()) {
              case 11 /* NumericLiteral */:
                  var value = 0;
                  try {
                      value = JSON.parse(_scanner.getTokenValue());
                      if (typeof value !== 'number') {
                          handleError(2 /* InvalidNumberFormat */);
                          value = 0;
                      }
                  }
                  catch (e) {
                      handleError(2 /* InvalidNumberFormat */);
                  }
                  onLiteralValue(value);
                  break;
              case 7 /* NullKeyword */:
                  onLiteralValue(null);
                  break;
              case 8 /* TrueKeyword */:
                  onLiteralValue(true);
                  break;
              case 9 /* FalseKeyword */:
                  onLiteralValue(false);
                  break;
              default:
                  return false;
          }
          scanNext();
          return true;
      }
      function parseProperty() {
          if (_scanner.getToken() !== 10 /* StringLiteral */) {
              handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
              return false;
          }
          parseString(false);
          if (_scanner.getToken() === 6 /* ColonToken */) {
              onSeparator(':');
              scanNext(); // consume colon
              if (!parseValue()) {
                  handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
              }
          }
          else {
              handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
          }
          return true;
      }
      function parseObject() {
          onObjectBegin();
          scanNext(); // consume open brace
          var needsComma = false;
          while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {
              if (_scanner.getToken() === 5 /* CommaToken */) {
                  if (!needsComma) {
                      handleError(4 /* ValueExpected */, [], []);
                  }
                  onSeparator(',');
                  scanNext(); // consume comma
                  if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {
                      break;
                  }
              }
              else if (needsComma) {
                  handleError(6 /* CommaExpected */, [], []);
              }
              if (!parseProperty()) {
                  handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);
              }
              needsComma = true;
          }
          onObjectEnd();
          if (_scanner.getToken() !== 2 /* CloseBraceToken */) {
              handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);
          }
          else {
              scanNext(); // consume close brace
          }
          return true;
      }
      function parseArray() {
          onArrayBegin();
          scanNext(); // consume open bracket
          var needsComma = false;
          while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {
              if (_scanner.getToken() === 5 /* CommaToken */) {
                  if (!needsComma) {
                      handleError(4 /* ValueExpected */, [], []);
                  }
                  onSeparator(',');
                  scanNext(); // consume comma
                  if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {
                      break;
                  }
              }
              else if (needsComma) {
                  handleError(6 /* CommaExpected */, [], []);
              }
              if (!parseValue()) {
                  handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);
              }
              needsComma = true;
          }
          onArrayEnd();
          if (_scanner.getToken() !== 4 /* CloseBracketToken */) {
              handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);
          }
          else {
              scanNext(); // consume close bracket
          }
          return true;
      }
      function parseValue() {
          switch (_scanner.getToken()) {
              case 3 /* OpenBracketToken */:
                  return parseArray();
              case 1 /* OpenBraceToken */:
                  return parseObject();
              case 10 /* StringLiteral */:
                  return parseString(true);
              default:
                  return parseLiteral();
          }
      }
      scanNext();
      if (_scanner.getToken() === 17 /* EOF */) {
          if (options.allowEmptyContent) {
              return true;
          }
          handleError(4 /* ValueExpected */, [], []);
          return false;
      }
      if (!parseValue()) {
          handleError(4 /* ValueExpected */, [], []);
          return false;
      }
      if (_scanner.getToken() !== 17 /* EOF */) {
          handleError(9 /* EndOfFileExpected */, [], []);
      }
      return true;
  }
  exports.visit = visit;
  /**
   * Takes JSON with JavaScript-style comments and remove
   * them. Optionally replaces every none-newline character
   * of comments with a replaceCharacter
   */
  function stripComments(text, replaceCh) {
      var _scanner = createScanner(text), parts = [], kind, offset = 0, pos;
      do {
          pos = _scanner.getPosition();
          kind = _scanner.scan();
          switch (kind) {
              case 12 /* LineCommentTrivia */:
              case 13 /* BlockCommentTrivia */:
              case 17 /* EOF */:
                  if (offset !== pos) {
                      parts.push(text.substring(offset, pos));
                  }
                  if (replaceCh !== undefined) {
                      parts.push(_scanner.getTokenValue().replace(/[^\r\n]/g, replaceCh));
                  }
                  offset = _scanner.getPosition();
                  break;
          }
      } while (kind !== 17 /* EOF */);
      return parts.join('');
  }
  exports.stripComments = stripComments;
  function getNodeType(value) {
      switch (typeof value) {
          case 'boolean': return 'boolean';
          case 'number': return 'number';
          case 'string': return 'string';
          case 'object': {
              if (!value) {
                  return 'null';
              }
              else if (Array.isArray(value)) {
                  return 'array';
              }
              return 'object';
          }
          default: return 'null';
      }
  }
  exports.getNodeType = getNodeType;
  return exports;
})()

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
var jsonFormatter = (function() {
  var exports = {};
  exports.__esModule = true;
  exports.isEOL = exports.getEOL = exports.format = void 0;
  var json_1 = json;
  function format(documentText, range, options) {
      var initialIndentLevel;
      var formatText;
      var formatTextStart;
      var rangeStart;
      var rangeEnd;
      if (range) {
          rangeStart = range.offset;
          rangeEnd = rangeStart + range.length;
          formatTextStart = rangeStart;
          while (formatTextStart > 0 && !isEOL(documentText, formatTextStart - 1)) {
              formatTextStart--;
          }
          var endOffset = rangeEnd;
          while (endOffset < documentText.length && !isEOL(documentText, endOffset)) {
              endOffset++;
          }
          formatText = documentText.substring(formatTextStart, endOffset);
          initialIndentLevel = computeIndentLevel(formatText, options);
      }
      else {
          formatText = documentText;
          initialIndentLevel = 0;
          formatTextStart = 0;
          rangeStart = 0;
          rangeEnd = documentText.length;
      }
      var eol = getEOL(options, documentText);
      var lineBreak = false;
      var indentLevel = 0;
      var indentValue;
      if (options.insertSpaces) {
          indentValue = repeat(' ', options.tabSize || 4);
      }
      else {
          indentValue = '\t';
      }
      var scanner = json_1.createScanner(formatText, false);
      var hasError = false;
      function newLineAndIndent() {
          return eol + repeat(indentValue, initialIndentLevel + indentLevel);
      }
      function scanNext() {
          var token = scanner.scan();
          lineBreak = false;
          while (token === 15 /* Trivia */ || token === 14 /* LineBreakTrivia */) {
              lineBreak = lineBreak || (token === 14 /* LineBreakTrivia */);
              token = scanner.scan();
          }
          hasError = token === 16 /* Unknown */ || scanner.getTokenError() !== 0 /* None */;
          return token;
      }
      var editOperations = [];
      function addEdit(text, startOffset, endOffset) {
          if (!hasError && startOffset < rangeEnd && endOffset > rangeStart && documentText.substring(startOffset, endOffset) !== text) {
              editOperations.push({ offset: startOffset, length: endOffset - startOffset, content: text });
          }
      }
      var firstToken = scanNext();
      if (firstToken !== 17 /* EOF */) {
          var firstTokenStart = scanner.getTokenOffset() + formatTextStart;
          var initialIndent = repeat(indentValue, initialIndentLevel);
          addEdit(initialIndent, formatTextStart, firstTokenStart);
      }
      while (firstToken !== 17 /* EOF */) {
          var firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
          var secondToken = scanNext();
          var replaceContent = '';
          while (!lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
              // comments on the same line: keep them on the same line, but ignore them otherwise
              var commentTokenStart = scanner.getTokenOffset() + formatTextStart;
              addEdit(' ', firstTokenEnd, commentTokenStart);
              firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart;
              replaceContent = secondToken === 12 /* LineCommentTrivia */ ? newLineAndIndent() : '';
              secondToken = scanNext();
          }
          if (secondToken === 2 /* CloseBraceToken */) {
              if (firstToken !== 1 /* OpenBraceToken */) {
                  indentLevel--;
                  replaceContent = newLineAndIndent();
              }
          }
          else if (secondToken === 4 /* CloseBracketToken */) {
              if (firstToken !== 3 /* OpenBracketToken */) {
                  indentLevel--;
                  replaceContent = newLineAndIndent();
              }
          }
          else {
              switch (firstToken) {
                  case 3 /* OpenBracketToken */:
                  case 1 /* OpenBraceToken */:
                      indentLevel++;
                      replaceContent = newLineAndIndent();
                      break;
                  case 5 /* CommaToken */:
                  case 12 /* LineCommentTrivia */:
                      replaceContent = newLineAndIndent();
                      break;
                  case 13 /* BlockCommentTrivia */:
                      if (lineBreak) {
                          replaceContent = newLineAndIndent();
                      }
                      else {
                          // symbol following comment on the same line: keep on same line, separate with ' '
                          replaceContent = ' ';
                      }
                      break;
                  case 6 /* ColonToken */:
                      replaceContent = ' ';
                      break;
                  case 10 /* StringLiteral */:
                      if (secondToken === 6 /* ColonToken */) {
                          replaceContent = '';
                          break;
                      }
                  // fall through
                  case 7 /* NullKeyword */:
                  case 8 /* TrueKeyword */:
                  case 9 /* FalseKeyword */:
                  case 11 /* NumericLiteral */:
                  case 2 /* CloseBraceToken */:
                  case 4 /* CloseBracketToken */:
                      if (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */) {
                          replaceContent = ' ';
                      }
                      else if (secondToken !== 5 /* CommaToken */ && secondToken !== 17 /* EOF */) {
                          hasError = true;
                      }
                      break;
                  case 16 /* Unknown */:
                      hasError = true;
                      break;
              }
              if (lineBreak && (secondToken === 12 /* LineCommentTrivia */ || secondToken === 13 /* BlockCommentTrivia */)) {
                  replaceContent = newLineAndIndent();
              }
          }
          var secondTokenStart = scanner.getTokenOffset() + formatTextStart;
          addEdit(replaceContent, firstTokenEnd, secondTokenStart);
          firstToken = secondToken;
      }
      return editOperations;
  }
  exports.format = format;
  function repeat(s, count) {
      var result = '';
      for (var i = 0; i < count; i++) {
          result += s;
      }
      return result;
  }
  function computeIndentLevel(content, options) {
      var i = 0;
      var nChars = 0;
      var tabSize = options.tabSize || 4;
      while (i < content.length) {
          var ch = content.charAt(i);
          if (ch === ' ') {
              nChars++;
          }
          else if (ch === '\t') {
              nChars += tabSize;
          }
          else {
              break;
          }
          i++;
      }
      return Math.floor(nChars / tabSize);
  }
  function getEOL(options, text) {
      for (var i = 0; i < text.length; i++) {
          var ch = text.charAt(i);
          if (ch === '\r') {
              if (i + 1 < text.length && text.charAt(i + 1) === '\n') {
                  return '\r\n';
              }
              return '\r';
          }
          else if (ch === '\n') {
              return '\n';
          }
      }
      return (options && options.eol) || '\n';
  }
  exports.getEOL = getEOL;
  function isEOL(text, offset) {
      return '\r\n'.indexOf(text.charAt(offset)) !== -1;
  }
  exports.isEOL = isEOL;
  return exports;
})()

var applyEditOperations = function(text, editOperations) {
  editOperations.reverse()
  var arr = text.split('');
  editOperations.forEach(op => {
   arr.splice(op.offset, op.length, op.content);
  })
  return arr.join('');
}
